Лекция №1.Выражения, подвыражения, типы Maple

В Maple существует множество типов переменных: от извест­ных вещественного (float), целого (integer) и массива (array) до тех, которые необходимы в аналитических преобразованиях: дробь (fraction), функция (function), индексная переменная (indexed), процедура (procedure), строка (string), множество (set), разложение (series), последовательность выражений (exprseq) и некоторые другие. Например, важным элементом Maple последовательности или списки (переменные типа list), подходящие для хранения коэффициентов полиномов, асимптотических разложений и т.д.

По умолчанию переменная считается скалярной и имеющей тип string. Это фактически математическая переменная, как х в формуле f(х). Для задания переменных других типов требуется явное их определение: при помощи оператора присваивания или команд, преобразующих тип. Например, для заведения массива из трех эле­ментов с именем а используется следующая конструкция:

> а:=аггау(1..3);

Сама переменная а при этом считается строковой (string), a любой элемент массива - индексной переменной (indexed). Если записать через запятые несколько величин и взять их в фигурные скоб­ки, то получится переменная типа set (множество). Именно таким образом предстают перед пользователем найденные Maple корни и задаются системы уравнений.

Информацию о типе той или иной переменной можно при помощи команды whattype.

         Все используемые в Maple выражения подразделяются на совокупность классов или групп, называемых также типами. Каждый тип определяется набором конкретных свойств. Например, тип prime (простые числа) – это совокупность натуральных чисел n, отличных от 1, которые не имеют других натуральных делителей, кроме 1 и n. Одно и то же выражение может относиться к разным типам. Скажем, число 7 принадлежит к следующим типам: numeric (числа), integer (целые числа), nonnegint (целые неотрицательные числа), posint (целые положительные числа), odd (нечетные числа), prime (простые числа), scalar (скаляры), algebraic (алгебраические числа), atomic (атомарные объекты). Перечень всех возможных простых типов выражений с гиперссылками на их описание можно получить по команде ?type. Из простых типов можно создавать структурированные типы. Кроме того, в пакете расширения TypeTools имеются средства для создания новых пользовательских типов.

Выражения и переменные обычно служат параметрами Maple. Стандартная команда выглядит следующим образом:

command(par1,par2,...,parn);

Здесь command - имя команды,   a parl,par2, . . . ,раrn - ее параметры.

Часть команд Maple вызывается автоматически, перед исполь­зованием других необходимо загрузить их в память командой readlib. Кроме того, многие команды являются частью пакетов (библиотек), и до запуска команды пакет должен быть загружен командой

with(package)

здесь package - имя пакета. Такими пакетами являются: DEtools, Gausslnt, genfunc, geometry, geom3d, group, liesymm, logic, networks, NPspinor, ntimapprox, padic, projgeom, totorder.

Если нужен вызов единственной команды command из пакета package, то можно пользоваться следующими конструкциями:

with(package,command), или

package[command](par1,par2,...,parn),

package - имя пакета, parl, par2,..., parn - параметры команды

Некоторые команды переопределяются при подключении ряда пакетов, так, например, команда трассировки trace после подключения пакета линейной алгебры linalg замещается командой следа матрицы. Предупреждение о переопределенных командах выдается при загрузке пакета.

Предупредим об опасности произвольного назначения имен переменных. Если имя переменной совпадает с именем какой-нибудь команды то такая команда становится недоступной в текущем сеан­се. Поэтому перед введением новой переменной name полезно удо­стовериться, что имя не занято, командой

?name

Появление окошка справки будет означать существование ко­манды с именем name.

Каждая команда должна завершаться разделителем: точкой с запятой (;) или двоеточием (:). Если ввод предложения завершается разделителем (;), то в строке под предложением сразу будет отклик: результат исполнения команды или сообщение об ошибке. Раздели­тель (:) используется для отмены вывода, когда команда выполня­ется системой, но ее результат не выводится на экран.

В Maple применяются круглые, квадратные и фигурные скоб­ки. Назначение круглых скобок - задавать порядок при построении математических выражений и обрамлять аргументы функций и па­раметры в записи команд. Квадратные скобки нужны для работы с индексными величинами. Фигурные скобки используются для фор­мирования множеств, например системы уравнений.

Для построения Maple-предложений нужны: знак равенства ( = ) при формировании уравнений и знак присвоения (:=) при зада­нии значений переменных. Различие в их использовании можно про­иллюстрировать следующим примером решения системы двух урав­нений. Аргументами команды решения уравнений solve являются множество уравнений (заключенные в фигурные скобки и разделен­ные запятой два уравнения) и множество переменных, для которых ищется решение. Результат решения присваивается некоторой пере­менной sols.

> sols:=solve({x+y=3,2*x=y},{x,y});

 

В результате получается множество решений sols :={х=1,у=2}

Как видно, получаемые решения представляют собой набор уравнений для указанных переменных. Если решений несколько, то выдаются все найденные решения (заметим, что это не обязательно все решения). Переменные х и у, однако, остаются неназначенными (неопределенными). Для того чтобы их определить, нужно восполь­зоваться командой assign:

> assign(sols); х;

В этом примере строка ввода состоит из двух команд, причем вторая выдает значение переменной х.

Вообще, для выдачи значения любой скалярной переменной достаточно в строке ввода указать имя самой переменной и завер­шить команду разделителем (;). Для просмотра содержимого индекс­ных переменных (например, с именем аrr) используется команда

eval(arr)

Тестирование выражений на конкретный тип

        Функция type(expr, ty) проверяет, относится ли выражение expr к типу ty, и если это так, возвращает логическое значение true. В противном случае возвращается false.

        Функция type(ty, type) проверяет, является ли ty типом, и если это так, возвращает логическое значение true. В противном случае возвращается false.

        Примеры 1. Первые три примера демонстрируют связь типа выражения от значений входящих в него определенных переменных.

> 

restart: type(a+b*c–7,`+`);

{¿}

 

true

 

> 

a := 7: type(a+b*c–7,`+`);

{¿}

 

false

 

> 

type(a+b*c–7,`*`);

{¿}

 

true

 

> 

type(scalar, type), type(atomic, type);

{¿}

 

true, true

 

> 

type(`–`, type), type(`/`, type), type(plot, type);

{¿}

 

false, false, false

■

Тестирование переменных

        Здесь: ex, ex1, ex2, …, exk – выражения; na – имя, список имен или множество имен; dependant, freeof – типы. Первый аргумент в D, E и F может быть множеством.

        Переменная считается фиктивной, если она является индексной в сумме, индексной в произведении, переменной интегрирования и переменной предельного перехода и т. п.. Неопределенная переменная, не являющаяся фиктивной, называется независимой.

        Функция depends(ex, na) является логической и возвращает true, если в ex имеется  хотя бы одно подвыражение (математическая функция), содержащая хотя бы одну независимую переменную из na. В противном случае возвращается false. Выражение ex может содержать обращения к функциям пользователя. Если ex – сложное выражение, то выяснение, является ли переменная независимой, может не привести к успеху. В этом случае перед использованием ex в A желательно его предварительно упростить. 

        Функция type(ex, dependent(na)) выполняется так же, как и A.

        Функция type(ex, freeof(na)) является логической и возвращает true, если в ex нет ни одного подвыражения, содержащего хотя бы одну независимую переменную из na. В противном случае возвращается false.

        Функция depends([ex1, ex2, …, exk], na) является логической и возвращает true, если хотя бы в одном из выражений ex1, ex2, …, exk имеется  хотя бы одно подвыражение, содержащая хотя бы одну независимую переменную из na.

        Функция type([ex1, ex2, …, exk], dependent(na)) выполняется так же, как и D.

        Функция type([ex1, ex2, …, exk], freeof(na)) является логической и возвращает true, если ни в одном из выражений ex1, ex2, …, exk нет ни одного подвыражения, содержащего хотя бы одну независимую переменную из na. В противном случае возвращается false.

        Примеры 1.

> 

ex := sin(x+cos(y))*z^2+a:

{Shift+¿}

 

depends(ex, x): depends(ex, [x, y, b]);

{¿}

 

true, true

 

> 

type([ex, (c+a)/b], dependent({b, w}));

{¿}

 

true

 

> 

depends(int(f(x), x = a..b), x);

{¿}

 

false

 

> 

type(sum(k^2, k = 1..n), freeof(k));

{¿}

 

true

 

> 

type(sum(k^2, k = 1..n), freeof(n));

{¿}

 

false

■

Выборка операндов из выражений

        Здесь n, m, n1, n2, …, nk – целые числа.

        Функция op(n, expr). При n > 0 функция A возвращает n-й операнд (подвыражение) из первого уровня вложенности выражения expr, считая от его начала. При n < 0 функция A возвращает |n|-й операнд из первого уровня вложенности выражения expr, считая от конца. При n = 0 функция A возвращает тип операнда expr.

        Функция op(n..m, expr) возвращает последовательность операндов из первого уровня вложенности выражения expr из диапазона n..m.  

        Функция op([n1, n2, …, nk], expr) возвращает операнд, который находится на первом уровне вложенности в позиции n1, на втором уровне – в позиции n2, …, на k-ом уровне в позиции nk. Более точно, op([n1, n2, …, nk], expr) = op(nk, op(…op(n2, op(n1, expr))…)).

        Функция op(expr) возвращает последовательность всех операндов первого уровня вложенности в выражении expr.

        Функция nops(expr) возвращает количество операндов первого уровня вложенности в выражении expr.

        Примеры 1.

> 

x := {a, b, c}: y := [e, f, g]: 

{Shift+¿}

 

op(1, x), op(2, y), op(-1, y), op(0, y), op(0, x);

{¿}

 

a, f, g, list, set

 

> 

restart: zz := a+x*y+c:

{Shift+¿}

> 

op(2..3, zz);

{¿}

 

x*y, c

 

> 

op([2, 2], zz);

{¿}

 

y

■

Поверхностные и вложенные типы

        Ранее рассмотренная команда type позволяет организовать тестирование выражений expr на принадлежность их к любому возможному типу ty. Среди огромного количества типов в Maple выделяют два их вида: поверхностные или верхнего уровня и вложенные или глубинные. Смысл этих названий вытекает из представления выражений в виде дерева. Если имя типа может оказаться в корне дерева какого-либо выражения, то этот тип называется поверхностным, иначе – вложенным. Именно поверхностный тип выражения и является типом этого выражения.

        Примеры поверхностных типов: `*`, `+`, `..`, `<=`, `<>`, `<`, `=`, `and`, `intersect`, `minus`, `not`,`or`, `union`, logical, relation, function, procedure, algebraic, anything, array, equation, even, float, fraction, indexed, integer, list, listlist, matrix, negative, numeric, odd, point, positive, radical, range, rational, RootOf, scalar, series, set, sqrt, string, table, taylor, trig, type, uneval, vector.  

        Примеры вложенных типов: algfun, algnum, applicable, constant, cubic, expanded, linear, polynom, quadratic, quartic, radfun, radnum, ratpoly.

        Пример 1. Выяснить тип выражения w = x*y+z^2–1/a.

        Решение. Ниже представлены три возможных варианта решения предложенной задачи. При использовании функции type предполагается знание имен типов. Функция whattype описана позже.

 

 

op(0, x*y+z^2–1/a);

{¿}

 

+

 

 

type(x*y+z^2–1/a,`+`);

{¿}

 

true

 

 

whattype(x*y+z^2–1/a);

{¿}

 

+

■

 

        Пример 1. Построить дерево выражения w = x*y+z^2–1/a, анализируя его с помощью функции op.

        Решение. Используя приведенные ниже вычисления, получаем дерево, представленное на рисунке 1.

 

> 

restart: w := x*y+z^2–1/a:

{Shift+¿}

 

op(0, w), op(w);

{¿}

 

 

> 

op(0, x*y), op(x*y);

{¿}

 

*, x, y

 

> 

op(0, z^2), op(z^2);

{¿}

 

^, z, 2

 

> 

op(0, 1/a), op(1/a);

{¿}

 

^, a, –1

 

> 

map(op, [x, y, z, 2, –1, a]);

{¿}

 

[x, y, z, 2, –1, a]

 

> 

map(whattype, [x, y, z, 2, –1, a]);

{¿}

 

[symbol, symbol, symbol, integer, integer, symbol]

■

 

      

Базисные типы

Среди поверхностных типов выделяют так называемые базисные типы. Функция whattype(expr) для выражения expr возвращает один из следующих его возможных базисных типов: `*`, `+`, `^`, `.`, `..`, `::`, `<`, `<=`, `<>`, `=`, `and`, `not`, `or`, integer, fraction, float, symbol, string, array, hfarray, set, list, table, Array, Matrix, Vector[column], Vector[row], function, procedure, indexed, series, uneval. Для последовательности выражений whattype возвращает exprseq, хотя этот вид данных в Maple типа не имеет. Тип выражения expr определяется с учетом порядка предпочтения выполняемых в нем операторов. Заметим, что многие из перечисленных выше 33 базисных типов имеются подтипы, так что общее количество типов превышает 200. Например, тип integer имеет подтипы: posint (положительные), negint (отрицательные), nonposint (не положительные), nonnegint (не отрицательные), even (четные), odd (нечетные), prime (простые).

        Примеры 1. Ниже для демонстрации различных базисных типов используется функция whattype. Функция map применяет whattype сразу для всех элементов списка, являющегося ее вторым аргументом.

 

> 

restart: w1:= a+b: w2 := a–b: w3 := a*b+c:

{Shift+¿}

 

whattype(w1), whattype(w2), whattype(w3);

{¿}

 

+, +, +

 

> 

a := 1: b := 2: c := 3.1:

{Shift+¿}

 

whattype(w1), whattype(w2), whattype(w3);

{¿}

 

integer, integer, float

 

> 

whattype(x/y); whattype(x^y); whattype(1/x);

{¿}

 

*, ^, ^

 

> 

whattype(x, y); whattype([x, y]); whattype({x, y});

{¿}

 

exprseq, list, set

 

> 

qw := proc(x) x^3 end proc: we := x ® x^3:

{Shift+¿}

 

map(whattype, [qw, qw(2), eval(qw)]);

{¿}

 

symbol, integer, procedure

 

> 

map(whattype, [x < y, x = y, x and y, not x]);

{¿}

 

[<, =, and, not]

 

 

Таблица 1

Порядок предпочтения операторов от высшего (1) к низшему (23)

 

№

 

Операторы

 

Название, пояснение, примеры

 

 

| |

Оператор конкатенации. Оператор используется в форме a | | b для соединения имени или строки a со значением выражения b.

Примеры: a) n := 5: a | | n Þ a5;

  b) “base” | | (1..3) Þ “base_1”, “base_2”, “base_3”.

1.    

:–

Оператор выборки членов модуля. Оператор используется для  экспортирования членов из модуля и его   подмодулей.

Примеры:

  a) m:-o (m – имя модуля, o – имя члена модуля);

  b) m:-e:-o (m – имя модуля, e – имя подмодуля,
       o – имя члена модуля).

2.    

::

Оператор типирования. Оператор используется для назначения конкретного типа переменным и поддерживает механизм автоматической проверки типов, передаваемых процедуре фактических параметров.

Примеры:

  a) g := proc(x::posint) local a::integer; ... end proc;

  b) typematch(x^3, b::anything^n::integer, 's'‘)’

3.    

%, %%, %%%

Нульарные ditto-операторы. Оператор используются для ссылки на последнее (%), предпоследнее (%%) и третье от конца (%%%) вычисленное выражение.

Пример. sin(%)+1.

4.    

`&name`

Нейтральные операторы (кроме &*). В &name операторах, определяемых пользователем, name любое допустимое в Maple имя или специальный символ, кроме символов: &, |, (, ), [, ], {, }, ;, :, ', `, #, %, \, <новая строка> <пробел>. Определяется нейтральный оператор так: `&name` := proc(x1, x2, …, xn) …end proc. Далее, &name можно использовать для вызова процедуры или как n-арный префиксный оператор в виде &name(a1, a2, …, an). Кроме того, при n = 2 его можно использовать и как бинарный инфиксный оператор в виде a1 &name a2.

Пример. `&su2` := proc(x, y) x^2+y^2 end;

3 &su2 5 Þ 34.

5.    

!

Оператор факториала. Оператор используется для вычисления факториала целых неотрицательных чисел.

Примеры: a) 0! Þ 1; b) 10! Þ 3628800.

6.    

^, @@

1. ^ – арифметический неассоциативный оператор возведения в степень.

Примеры: a) (a^b)^c Þ ;  b) a^(b^c) Þ .

2. @@ – неассоциативный оператор повторной композиции функции.

Примеры. a)  (sin@@1)(x) Þ sin(x);

  b)  (cos@@3)(t) Þ cos(3)(t), то есть cos(cos(cos(t))).

7.    

., *, &*, /, @

intersect

1. . – оператор скалярного умножения.

Примеры: a) 11 . 6 Þ 66;

  b) a := <1, 2, 3>: b := <2, 1, 1>: a.b Þ 7;

  c) c := Array(1..2, 1..3, [[1, 2, 3], [4, 5, 6]]):

      d := Array(1..2, 1..3, [[0, 1, 0], [2, 1, 1]]):

      

2. * и / – арифметические операторы умножения и деления.

3. &* – нейтральный оператор некоммутативного умножения.

4. @ – оператор композиции функций.

Примеры. a) sin@cos Þ sin@cos;

  b) (sin@cos)(x) Þ sin(cos(x)).

5. intersect – оператор пересечения множеств.

Пример. x := {a, b, c, d, e, f}: y := {a, d, 1, 2, 3, e}:

  intersect(x, y) Þ {a, d, e}.

8.    

+, –, union, minus

1. +, –   –   арифметические операторы сложения и вычитания.

2. union и minus – операторы объединения и разности множеств.

Примеры. x := {a, b, c, d, e, f}: y := {a, d, 1, 2, 3, e}:

  a) x union y Þ {1, 2, 3, a, b, d, f, c, e};

  b) x minus y Þ {b, f, c}.

9.    

mod

Оператор нахождения остатка. Оператор используется для вычисления остатка при делении a на m (a – целые число или многочлен с целыми коэффициентами, m – целое число).

Примеры. a) 76 mod 5 Þ 1;

  b) 17*x^3–19*x+1 mod 5 Þ 2x3+x+1.

10.     

subset

Оператор “быть подмножеством”.

Пример. {a, 7} subset {a, 8, 7} Þ true.

11.     

..

Оператор диапазона.

Примеры: a) expr1..expr2; b) 1..5; c) $ 1..4 Þ 1, 2, 3, 4;

  d) cat(a, 1..5) Þ a1, a2, a3, a4, a5;

12.     

<, <=, >, >=,

=, <>, in

Операторы отношения. Операторы используются для формирования булевых выражений.

Примеры: a) 11 <> a+b; is(c in [c, d]) Þ true;

  b) evalb(5 in {1, 2, 3, 4}) Þ false;

13.     

$

Оператор последовательности. Оператор используется для формирования последовательности выражений.

Примеры: a) $ 3..6 Þ (3, 4, 5, 6);

  b) x^2 $ x = 1..3 Þ 1, 4, 9;

14.     

not

Оператор отрицания (“не”). Унарный булевский оператор not используется в логических выражениях трехзначной логики (true – истина, false – ложь, FAIL – неудача). Таблица истинности для “not a”:

a

not a

true

false

false

true

FAIL

FAIL

Пример. not 5 < 7 Þ false.

15.     

and

Оператор “и”. Бинарный булевский оператор and используется для формирования логических выражений трехзначной логики (true – истина, false – ложь, FAIL – неудача). Таблица истинности для “a and b”:

a and b

true

false

FAIL

true

true

false

FAIL

false

false

false

false

FAIL

FAIL

false

FAIL

Пример. 5 < 7 and 3 < 7 Þ true.

16.     

or

Оператор “или”. Бинарный булевский оператор с таблицей истинности для “a or b”:

a or b

true

false

FAIL

true

true

true

true

false

true

false

FAIL

FAIL

true

FAIL

FAIL

Пример. 5 < 7 or 7 < 3 Þ true.

17.     

xor

Оператор “исключающее или”. Бинарный булевский оператор с таблицей истинности для “a xor b”:

a xor b

true

false

FAIL

true

false

true

FAIL

false

true

false

FAIL

FAIL

FAIL

FAIL

FAIL

Пример. 5 < 7 xor 3 < 7 Þ false.

18.     

implies

Оператор импликации. Бинарный булевский оператор с таблицей истинности для “a implies b”:

 

a implies b

b

true

false

FAIL

 

a

true

true

false

FAIL

false

true

true

true

FAIL

true

FAIL

FAIL

Пример. 15 < 7 implies 9 < 3 Þ true.

19.     

®

Функциональный оператор. Оператор используется для создания простейшей процедуры, в теле которой одно выражение.

Примеры: a) g := x ® x^2; b) qw := (x, y) := x^3+y^3.

20.     

,

Оператор “запятая”. Оператор используется для создания последовательности выражений.

Примеры: a) 1, 2, 3, 5; b) expr1, expr2, …, expr9.

21.     

assuming

Оператор “при условии” (при допущении, в случае).

Оператор используется для вычисления выражений.

Пример. expr assuming x::posint.

22.     

:=

Оператор присваивания.  

Примеры: a) x := expr; b) gg(5) := qwe; c) u, v := a, b.

      

 

 

Структурные типы

        Из простых типов можно конструировать структурные типы. Подобные сложные или составные типы формируются из простых типов так же, как и выражения из отдельных термов. Ограничимся приведением нескольких примеров, где  ty1, ty2, …, tyk – простые типы:

 

{ty1, ty2, …, tyk}

–

выражение любого из предложенных типов;

[ty1, ty2, …, tyk]

–

список выражений с указанными типами;

`ty1`

–

невычисляемое выражение данного типа;

complex(numeric)

–

комплексная константа;

ty1 = ty2

–

уравнение с соответствующими типами выражений в его левой и правой части;

ty1 <> ty2

–

неравенство между выражениями указанного типа;

ty1 < ty2

ty1 <= ty2

ty1 > ty2

ty1 >= ty2

–

соответствующие отношения между выражениями указанного типа;

ty1..ty2

–

диапазон;

ty1 and ty2

ty1 or ty2

not ty1

–

логические операторы над выражениями указанного типа;

ty1^ ty2

–

степень;

ty1 || ty2

–

конкатенация;

`&+`(ty1, ty2, …, tyk)

–

сумма выражений соответствующего типа;

`&*`(ty1, ty2, …, tyk)

–

произведение выражений соответствующего типа;

fcntype

–

функция специального типа (см. ?type[structured]).

Примеры 1.

> 

T := {even, prime}:

{Shift+¿}

 

type(11, T), type(12, T), type(15, T);

{¿}

 

true, true, false

 

> 

type([7, “qwerty”, x ® x^2], [numeric, string, procedure]);

{¿}

 

true

 

> 

type(qw^3, name^numeric), type(qw^a, name^numeric);

{¿}

 

true, false

■

Выборки и удаления подвыражений из выражений

        Здесь: select (выбрать), remove (удалить), selectremove – имена функций; bool – имя процедуры, возвращающей булевы значения; expr – произвольное выражение; a1, a2, …, ak – необязательные дополнительные фактические параметры, передаваемые процедуре bool. В частности, bool может быть функцией type. При выполнении A – C выборки и удаления подвыражений происходят с первого уровня вложенности expr, а само выражение expr не изменяяя. Возвращаемый объект имеет тот же тип, что и expr.

        Функция select(bool, expr, a1, a2, …, ak) возвращает объект, получаемый выборкой из expr всех его подвыражений, которые удовлетворяют процедуре bool.

        Функция remove(bool, expr, a1, a2, …, ak) возвращает объект, получаемый удалением из expr всех его подвыражений, которые удовлетворяют процедуре bool.

        Функция selectremove(bool, expr, a1, …, ak) возвращает последовательность из двух объектов, первый из которых формируется функцией A, а второй – функцией B.

        Примеры 1. Обратите внимание возможность выборки и удаления из выражений подвыражений конкретного типа (два последних примера).

> 

select(isprime, [$1..50]);

{¿}

 

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

 

> 

as := [7, 5, 11, 8, 4, 5, 7, 2]:

{Shift+¿}

 

qw := proc(x, a) x > a end proc:

{Shift+¿}

 

select(qw, as, 7), remove(qw, as, 7);

{¿}

 

[11, 8], [7, 5, 4, 5, 7, 2]

 

> 

selectremove(qw, as, 7);

{¿}

 

[11, 8], [7, 5, 4, 5, 7, 2]

 

> 

g := b*exp(a*x)*cos(y+x)*ln(y);

{Shift+¿}

 

select(has, g, x), select(has, g, y);

{¿}

 

e(ax) cos(y+x), cos(y+x)*ln(y)

 

> 

selectremove(has, g, x);

{¿}

 

e(ax) cos(y+x), b ln(y)

 

> 

select(type,  [b+x, x, a+p], `+`);

{¿}

 

[b+x, a+p]

 

> 

select(type, [sin(b), x+cos(a), gg(x)], function);

{¿}

 

[sin(b), gg(x)]

■

                           

Конвертирование типов

        Функция convert(expr, form, arg1, arg2, …, argk) конвертирует выражение из одного типа или формы в другой тип или форму form. Аргументы arg1, arg2, …, argk не обязательны. Возможности этой функции чрезвычайно многообразны. Ограничимся рассмотрением лишь некоторых примеров.

 

        Примеры 1.

 

> 

s := 1, 2, 3, 4, 5: se := {1, 2, 3, 4, 5}: li := [1, 2, 3, 4, 5]:

{Shift+¿}

 

convert('s', set), convert(li, set);

{¿}

 

{1, 2, 3, 4, 5}, {1, 2, 3, 4, 5}

 

> 

convert('s', list), convert(se, list);

{¿}

 

[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]

 

> 

convert(13, binary), convert(15, hex);  # = hexadecimal

{¿}

 

1101, F

 

> 

convert(XVIII, arabic), convert(19, roman);

{¿}

 

18, “XIX”

 

> 

convert(abs(1+abs(x)), piecewise);

{¿}

 

 

> 

convert(a+b+c*d, string);

{¿}

 

“a+b+c*d”

 

> 

p := x^5–2*x^4–2*x^3+4*x^2+x–2: q := x^2+x+1:

{Shift+¿}

 

convert(p/q, parfrac, x);

{¿}

 

 

> 

convert(RootOf(z^3+3*z–5, index = 2), radical):

{Shift+¿}

 

simplify(%);

{¿}

 

 

> 

convert(signum(x), abs), convert(0.129876, fraction);

{¿}

 

 

> 

convert([[1, 2], [3, 4]], array);

{¿}

 

 

> 

convert(a*D(y)(x) + D(w)(x), diff, x);

{¿}

 

 

■